home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / RegularExp.C < prev    next >
C/C++ Source or Header  |  1992-05-05  |  5KB  |  178 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "RegularExp.h"
  6.  
  7. #include "Class.h"
  8. #include "String.h"
  9. #include "Math.h"
  10.  
  11. SmartRegularExp gRexDouble("\\(+\\|-\\)?[0-9]*\\(\\.[0-9]*\\)?\\([eE]\\(+\\|-\\)?[0-9]*\\)?"),
  12.         gRexInt("\\(+\\|-\\)?[0-9]*");
  13.         
  14. //---- C++ interface to regex.c ------------------------------------------------
  15.  
  16. extern "C" {
  17.     char *re_compile_pattern (char *pat, int,struct re_pattern_buffer *bufp);
  18.     struct re_pattern_buffer *re_get_pattern_buffer(bool case_sensitive);
  19.     void free_re_pattern_buffer(struct re_pattern_buffer *);
  20.     void re_compile_fastmap (struct re_pattern_buffer *);
  21.     int re_match (struct re_pattern_buffer *, char *, int, int, RegExRegs *regs);
  22.     int re_match_2 (struct re_pattern_buffer *, char *, int, char *, int, int, 
  23.                         RegExRegs *regs, int);
  24.     int re_search (struct re_pattern_buffer *, char *str, int size, 
  25.                    int start, int range, RegExRegs*,int *len);
  26.     int re_search_2 (struct re_pattern_buffer *, char *str1, int size1,
  27.         char *str2, int size2, int startpos, int range, RegExRegs *regs,
  28.         int mstop, int *len); 
  29. }
  30.  
  31. //---- Regular Expression ------------------------------------------------------
  32.  
  33. NewMetaImpl(RegularExp,Object, (TP(source), TP(result), TB(caseSensitive), TB(fastSearch)));
  34.  
  35. RegularExp::RegularExp(char *pat, bool cs, bool fs)
  36. {
  37.     if (pat == 0)
  38.     pat= "";
  39.     caseSensitive= cs;
  40.     fastSearch= fs;
  41.     pb= re_get_pattern_buffer(caseSensitive);
  42.     source= strsave(pat);
  43.     result= re_compile_pattern(source, strlen(source), pb);
  44.     if (fastSearch)
  45.     re_compile_fastmap(pb);
  46. }
  47.  
  48. RegularExp::~RegularExp()
  49. {
  50.     if (pb) {
  51.     free_re_pattern_buffer(pb);
  52.     pb= 0;
  53.     }
  54.     SafeDelete(source);
  55. }
  56.  
  57. void RegularExp::Reset(char *pat, bool cs, bool fs)
  58. {
  59.     if (strcmp(pat, source) == 0 && cs == caseSensitive && fs == fastSearch)
  60.     return; // no recompilation necessary
  61.     if (pb)
  62.     free_re_pattern_buffer(pb);
  63.     strreplace(&source, pat);
  64.     caseSensitive= cs;
  65.     fastSearch= fs;
  66.     pb= re_get_pattern_buffer(caseSensitive);
  67.     result= re_compile_pattern (pat, strlen(pat), pb);
  68.     if (fastSearch)
  69.     re_compile_fastmap (pb);
  70. }
  71.  
  72. char *RegularExp::GetExprState()
  73. {
  74.     return result;
  75. } 
  76.  
  77. int RegularExp::Match (char *pat, int pos, int len, RegExRegs *regs)
  78. {
  79.     if (len == -1) 
  80.     len= strlen(pat);
  81.     return re_match(pb, pat, len, pos, regs);    
  82. } 
  83.  
  84. int RegularExp::Match2 (char *str1, char *str2, int len1,
  85.             int len2, int pos, int stopMatchAt, RegExRegs *regs)
  86. {
  87.     if (len1 == -1) 
  88.     len1= strlen(str1);
  89.     if (len2 == -1)
  90.     len2= strlen(str2);
  91.     stopMatchAt= Math::Range(0, len1+len2, stopMatchAt);
  92.     return re_match_2(pb, str1, len1, str2, len2, pos, regs, stopMatchAt);
  93. } 
  94.  
  95. int RegularExp::SearchForward (char *string, int *nMatched,int start,  
  96.                     int len, int itsRange, RegExRegs *regs)
  97. {
  98.     if (len == -1) 
  99.     len= strlen(string);
  100.     start= Math::Range(0,len-1,start);
  101.     itsRange= Math::Range(0,len - start,itsRange);
  102.     return re_search(pb, string, len, start, itsRange, regs, nMatched);
  103. }
  104.  
  105. int RegularExp::SearchBackward (char *string, int *nMatched,int start,  
  106.                     int len, int itsRange, RegExRegs *regs)
  107. {
  108.     if (len == -1) 
  109.     len= strlen(string);
  110.     start= Math::Range(0,len,start);
  111.     itsRange= Math::Range(0,start,itsRange);
  112.     return re_search(pb, string, len, start, -itsRange, regs, nMatched);
  113. }
  114.  
  115. int RegularExp::SearchForward2 (char *str1, int len1, char *str2, int len2,
  116.             int start, int itsRange, RegExRegs *regs, int *nMatched)
  117. {
  118.     if (len1 == -1) 
  119.     len1= strlen(str1);
  120.     if (len2 == -1)
  121.     len2= strlen(str2);
  122.     int clen= len1+len2;
  123.     start= Math::Range(0, clen-1, start);
  124.     itsRange= Math::Range(0,clen - start,itsRange);
  125.     int mstop= start+itsRange;
  126.     return re_search_2(pb, str1, len1, str2, len2, start, itsRange, regs, mstop, nMatched); 
  127. }
  128.  
  129. int RegularExp::SearchBackward2 (char *str1,int len1, char *str2, int len2,
  130.             int start, int itsRange, RegExRegs *regs, int *nMatched)
  131. {
  132.     if (len1 == -1) 
  133.     len1= strlen(str1);
  134.     if (len2 == -1)
  135.     len2= strlen(str2);
  136.     int clen= len1+len2;
  137.     start= Math::Range(0, clen-1, start);
  138.     itsRange= Math::Range(0,start+1,itsRange);
  139.     int mstop= start-itsRange;
  140.     return re_search_2(pb, str1, len1, str2, len2, start, -itsRange, regs, mstop, nMatched); 
  141. }
  142.  
  143. const char *RegularExp::GetPattern()
  144. {
  145.     return source;
  146. }
  147.  
  148. const char *RegularExp::MatchWordPattern()
  149. {
  150.     return "\\<%s\\>";
  151. }
  152.  
  153. OStream& RegularExp::PrintOn(OStream& s)
  154. {
  155.     Object::PrintOn(s);
  156.     s.PrintString(source);
  157.     return s SP << caseSensitive SP << fastSearch SP;
  158. }
  159.  
  160. IStream& RegularExp::ReadFrom(IStream& s)
  161. {
  162.     Object::ReadFrom(s);
  163.     SafeDelete(source);
  164.     s.ReadString(&source);
  165.     s >> Bool(caseSensitive) >> Bool(fastSearch);
  166.     pb= re_get_pattern_buffer(caseSensitive);
  167.     result= re_compile_pattern (source, strlen(source), pb);
  168.     if (fastSearch)
  169.     re_compile_fastmap(pb);
  170.     return s;
  171. }
  172.  
  173. void RegularExp::InspectorId(char *buf, int sz)
  174. {
  175.     strn0cpy(buf, source, sz);
  176. }
  177.  
  178.